System and Method for Distributed Security

ABSTRACT

A security architecture in which a security module is integrated in a client machine, wherein the client machine includes a local host that is untrusted. The security module performs encryption and decryption algorithms, authentication, and public key processing. The security module also includes separate key caches for key encryption keys and application keys. A security module can also interface a cryptographic accelerator through an application key cache. The security module can authorize a public key and an associated key server. That public key can subsequently be used to authorize additional key servers. Any of the authorized key servers can use their public keys to authorize the public keys of additional key servers. Secure authenticated communications can then transpire between the client and any of these key servers. Such a connection is created by a secure handshake process that takes place between the client and the key server. A time value can be sent from the key server to the client, allowing for secure revocation of keys. In addition, secure configuration messages can be sent to the security module.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.11/873,220, filed Oct. 16, 2007, assigned U.S. Pat. No. 8,713,309, whichis a divisional of U.S. patent application Ser. No. 10/452,221, filedJun. 3, 2003, now U.S. Pat. No. 7,289,632, both of which areincorporated by reference herein their entireties.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The invention described herein relates to information processing and tothe security of network information systems in particular.

2. Related Art

One of the problems common to information security systems isminimization of a security boundary. A security boundary can be viewedas a conceptual demarcation of information and logic that must not becompromised. Logic within the security boundary performssecurity-related actions, such as encryption, decryption,authentication, and any other processes that require the handling ofsensitive information. Preferably, such a boundary is minimized. Thisallows a designer to treat much of the surrounding system as untrusted.A complementary design goal is to avoid overloading trusted processingassets. Preferably, as much processing as possible should be left tountrusted logic. This permits the trusted logic to concentrate onsecurity related operations. Moreover, such processes can becomputationally intensive, e.g., the mathematical processing associatedwith public key cryptography. Finally, while a security boundary must bewell defined, it is also desirable to define this boundary in a flexiblemanner. This allows a designer to add logic to the portion of a designthat is inside a security boundary. This increases the designer'soptions, and allows the addition or deletion of sensitive logic after asystem is fielded.

What is needed, therefore, is a security architecture that provides fora minimal security boundary and allows as much processing as possible tobe performed outside the boundary. This would allow for secure,authenticated transmission of both traffic and cryptographic keys usingminimal logic. Moreover, such a system would allow the easy and secureconfiguration or reconfiguration of logic within the security boundary.

SUMMARY OF THE INVENTION

The invention described herein is a security architecture in which asecurity module is integrated in a client machine, wherein the clientmachine includes a local host that is untrasted. In an embodiment of theinvention, the security module is implemented in hardware, and includeslogic for performing one or more cryptographic operations such asencryption, decryption, and public key processing. In an embodiment ofthe invention, the security module also includes separate key caches forkey encryption keys (KEKs) and for application keys. A security modulecan also interface additional logic external to the module, where theexternal logic performs arithmetic operations offloaded by the securitymodule for purposes of speeding up cryptographic processing. Suchexternal logic is referred to as a cryptographic accelerator.

In the invention described herein, the security module is preprogrammedwith the authorization data for a key server. If this authorization datamatches authorization data that is calculated based on the public key ofa prospective authorized key server, then that key server and its publickey are viewed as being authorized. That public key can subsequently beused to authorize additional entities, such as additional key servers.Further, any of the authorized key servers can use their public keys toauthorize the public keys of additional key servers. In this manner, alist can be constructed of authorized public keys that correspond torespective authorized key servers.

Secure authenticated communications can then transpire between theclient and any of these authorized key servers. Such a connection iscreated by a secure handshake process that takes place between theclient and an authorized key server.

Given one or more authorized key servers and a secure, authenticatedconnection between the key server and the client, a number ofoperational features are now feasible. Cryptographic keys can now bepassed from the key server to the security module. Moreover, a timevalue can also be sent from the key server to the client, such that acountdown timer at the security module is programmed with this timevalue. Any key associated with the time value can only be used until thetimer decrements to zero. This allows for secure revocation of keys. Inaddition, secure configuration messages can be sent to the securitymodule, allowing configuration or reconfiguration of logic within themodule. Any such configuration message is sent to the security moduleaccompanied by a signature that is created using one of the abovementioned authorized public keys. This allows for authenticated, securecontrol of a module's configuration. Moreover, such reconfiguration canbe performed even after a system is fielded. In addition, the presenceof a distinct application key cache in the security module allows for aninterface to logic external to the module, such as a cryptographicaccelerator. This allows for straightforward inclusion of such anaccelerator into the security boundary. Moreover, security functionalityis enhanced without modification to the security module itself.

BRIEF DESCRIPTION OF THE FIGURES

The present invention will be described with reference to theaccompanying drawings. In the drawings, like reference numbers generallyindicate identical, functionally similar, and/or structurally similarelements. The drawing in which an element first appears is indicated bythe left most digit in the reference number.

FIG. 1 is a block diagram illustrating an embodiment of the invention inwhich an authorized server public key is transferred to a securitymodule for purposes of verifying the authorization of a key server.

FIG. 2 is a block diagram of an embodiment of the invention in which asecure handshake takes place between a key server and a client.

FIG. 3 is a block diagram illustrating the transfer of a configurationmessage from a local host to a security module in a client, according toan embodiment of the invention.

FIG. 4 is a block diagram illustrating the functional components of asecurity module, according to an embodiment of the invention.

FIG. 5 is a flowchart illustrating the process of authorizing one ormore key servers, according to an embodiment of the invention.

FIG. 6 is a flowchart illustrating the process of verifying theauthorization of an initial, or root, key server according to anembodiment of the invention.

FIG. 7 is a flowchart illustrating the secure handshake process betweena client and a key server, according to an embodiment of the invention.

FIG. 8 is a flowchart illustrating the process of verifying a signedsession public key, according to an embodiment of the invention.

FIG. 9 is a flowchart illustrating the process of verifying a handshake,according to an embodiment of the invention.

FIG. 10 is a flowchart illustrating the process of securely transferringa configuration message from a local host to a security module,according to an embodiment of the invention.

FIG. 11 is a flowchart illustrating the process of transferring a timevalue to a security module for purposes of setting a countdown timer inthe security module, according to an embodiment of the invention.

FIG. 12 is a flowchart illustrating the process of reconfiguring asecurity module according to a secure configuration message, accordingto an embodiment of the invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

A preferred embodiment of the present invention is now described. Whilespecific configurations and arrangements are discussed, it should beunderstood that this is done for illustrative purposes only. A personskilled in the relevant art will recognize that other configurations andarrangements can be used without departing from the spirit and scope ofthe invention. It would be apparent to a person skilled in the relevantart that this invention can also be employed in a variety of othersystems, networks, and applications.

I. Overview

The invention described herein is a security architecture in which asecurity module is integrated in a client machine, wherein the clientmachine includes a local host that is untrusted. In an embodiment of theinvention, the security module is implemented in hardware, and includeslogic for performing one or more cryptographic operations such asencryption and decryption (e.g., the Advanced Encryption Standard (AES)or the triple Data Encryption Standard (3DES)), authentication (e.g.,the Secure Hashing Algorithm (SHA1)) and public key processing (e.g.,the Rivest Shamir Adleman (RSA) or Diffie-Hellman algorithms). In anembodiment of the invention, the security module also includes separatekey caches for key encryption keys (KEKs) and for application keys. Asecurity module can also interface additional logic external to themodule, logic that performs arithmetic operations offloaded by thesecurity module for purposes of speeding up cryptographic processing.Such external logic is referred to as a cryptographic accelerator.

In the invention described herein, the security module is preprogrammedwith the authorization data for a key server. If this authorization datamatches authorization data that is calculated based on the public key ofa prospective authorized key server, then that key server and its publickey are viewed as being authorized. That public key can subsequently beused to authorize additional entities, such as additional key servers.Further, any of the authorized key servers can use their public keys toauthorize the public keys of additional key servers. In this manner, alist can be constructed of authorized public keys that correspond toauthorized key servers. Secure authenticated communications can thentranspire between the client and any of these authorized key servers.Such a connection is created by a secure handshake process that takesplace between the client and the authorized key server.

Given one or more authorized key servers and a secure, authenticatedconnection between the key server and the client, a number ofoperational features are now feasible. Cryptographic keys can now bepassed from the key server to the security module. Moreover, a timevalue can also be sent from the key server to the client, such that acountdown timer is programmed with this time value. Any key associatedwith the time value can only be used until the timer decrements to zero.This allows for secure revocation of keys. In addition, secureconfiguration messages can be sent to the security module, allowingconfiguration or reconfiguration of logic within the module. Any suchconfiguration message is sent to the security module accompanied by asignature that is created using one of the above mentioned authorizedpublic keys. This allows for authenticated, secure control of a module'sconfiguration. Moreover, such reconfiguration can be performed evenafter a system is fielded. In addition, the presence of a distinctapplication key cache in the security module allows for an interface tologic that is external to the module, such as a cryptographicaccelerator. This permits straightforward inclusion of such anaccelerator into the security boundary. Moreover, the functionality ofthe security module is enhanced without modification to the securitymodule itself.

II. System

The system of the invention is illustrated generally in FIG. 1. A client110 is shown in communication with a key server 120. Internal to client110 is security module 130, local host 140, and a cryptographicaccelerator 150 in communication with security module 130. Securitymodule 130 is preprogrammed to contain server authorization dataassociated with a particular key server and the server's public key. Inan embodiment of the invention, the server authorization data is asecure hash value based on the public key of the key server. The hashingprocess used to create the server authorization data can, for example,be the SHA1 process. Local host 140 is shown transferring an authorizedserver public key 160 to a security module 130. Security module 130 thencalculates the secure hash value based on the authorized server publickey 160. If the resulting value matches the pre-stored serverauthorization data, then the authorization of the associated key serveris verified. If key server 120 is the key server associated with publickey 160, then key server 120 is trusted by client 120 and a secureconnection between client 110 and key server 120 can now be created.

Because security module 130 is now aware of a validated public key,i.e., authorized server public key 160, additional entities can now beauthorized. Public key 160, for example, can now be used to sign thepublic key of another entity, such as another key server. Hence, anotherkey server and its public key are now recognized as authorized. Eitherof the now authorized public keys can then be used to sign yet anotherpubic key associated with yet another key server. In this way, a chaincan be built consisting of authorized key servers and their public keys.Authorized server public key 160 can therefore be thought of as a rootvalue for this chain. The process of verifying public keys will bedescribed in greater detail below.

FIG. 2 illustrates generally the handshake process that transpiresbetween security module 130 and key server 120. This allows securecommunications to take place between security module 130 and key server120. As will be described in greater detail below, the handshake 210serves to implement a transport layer security (TLS) protocol. Note thatat this point, one or more server public keys have been authorized.These are shown as authorized server public key PK₁₆₀, PK_(X), andPK_(Y).

Given that one or more authorized server public keys are now availableto the client 110, there are a number of ways in which such keys can beused. For example, as shown in FIG. 3, a configuration message 310 cannow be transferred to security module 130 in a secure manner. Local host140 may, for example, hold persistent data that must be transferred tosecurity module 130 in the form of a message 310. Since local host 140is not trusted, however, a mechanism is required by which this transfercan take place in a secure manner. In an embodiment of the invention, anauthorized signature accompanies any data transferred to the securitymodule 130 from local host 140. The persistent data is stored at localhost 140 in encrypted form, along with the authorized signature. Theauthorized signature will have been created using one of the authorizedserver public keys described above. The security module will not loadany persistent data unless the signature accompanies the data. Such amechanism prevents spoofing of security module 130.

In addition, a key can be viewed as persistent data. It may benecessary, for example, to transfer a key to security module 130 in asecure manner. In such a situation, a time value is also transferred tosecurity module 130. The time value can be used to set a countdown timerin security module 130, in accordance with a system security policy. Anykey that is associated with the time value is rendered unusable once thecountdown timer reaches zero. This mechanism therefore serves as a wayin which key expiration can be enforced. As will be described in greaterdetail below, any subsequently received time value serves to renderunusable any preexisting keys that had been associated with a previouslysent time value. In one embodiment of the invention, one tick of thecountdown timer corresponds to one second. In addition, in an embodimentof the invention, the time value includes a sequence number so thepreviously transmitted time values cannot be captured by an adversaryand replayed to the security module 130.

Configuration message 310 can also be used to configure the logic ofsecurity module 130. It may be desirable, for example, to reconfiguresecurity module 130 so as to impose some minimum or maximum key length.Given the above mechanism, such a reconfiguration can be implementedusing a configuration message 310. This represents a secure method bywhich a reconfiguration can be implemented while the system is in thefield. Such a configuration process would be useful in situations whereit is desirable to build and field a security module 130 but configureit differently depending on whether the security module is to beexported. For some markets, for example, one key length would bepermitted; in another market, a different key length would be allowed.This could be implemented using an “in field” upgrade as describedabove.

Configuration message 310 can also be used to constrain the ways inwhich a given key can be used, as a way of enforcing a system securitypolicy. If a key is to be used strictly for signing, for example, or forboth signing and encryption, such constraints can be conveyed tosecurity module 130 through configuration message 310. Alternatively, agiven key may be constrained to be used only with regard to certainother entities, e.g., only to secure communications with a server.

FIG. 4 illustrates a more detailed block diagram of security module 130.In addition to logic for a variety of cryptographic processes, such asrandom number generation (RNG) (block 410), SHA1 (block 420), and 3DES(block 430), security module 130 also includes key caches. Securitymodule 130 includes a KEK cache 440, and a separate application keycache 450. The application key cache includes an interface 460 to whichadditional processing logic can be connected. In an embodiment of theinvention, for example, a cryptographic accelerator (not shown in FIG.4) can be connected to security module 130 at this point. If this is thecase, the security boundary effectively includes the cryptographicaccelerator as well as the security module 130. This represents anarchitecture in which additional cryptographic logic can be addedwithout having to modify the logic already existing in security module130.

III. Method

In general, the invention described herein establishes a secureauthenticated connection between a key server and the client. Once a keyserver is recognized as authorized, a secure handshake can take place toenable a secure session in which keys or other information can betransferred between the key server and the client. The authorization ofa key server and its public key allows a number of other operations totake place securely, such as the transfer of configuration messages.

FIG. 5 illustrates the process by which one or more key servers andtheir respective public keys are recognized as authorized. The processbegins at step 510. In step 520, a determination is made as to whetherthe authorization of a server public key has been verified. If so, adetermination is made in step 530 as to whether chaining has beenenabled. In this embodiment of the invention, a flag in the securitymodule can be set or reset to indicate that the verified public key ofstep 520 can be used to authorize additional key servers and theirpublic keys. If chaining is enabled in step 530, then a determination ismade in step 540 as to whether there is an additional server toauthorize. If so, then the process proceeds to step 550. Here, averified server public key is used to sign the public key pair ofanother party to recognize that party as an authorized server. In step560, that party's public key is added to the list of authorized serverpublic keys. Hence this latest public key can also authorize aperspective additional key server. The process then returns to step 540in which a determination is made as to whether there is an additionalserver to authorize. In this way, a chain of authorized servers can becreated and a list of their respective public keys maintained.

Step 520, the step of verifying the authorization of a server publickey, is illustrated in greater detail in FIG. 6. The process begins atstep 610. In step 620, the security module reads its preprogrammedserver authorization data. The server authorization data is the hashvalue that is based on an authorized server public key. In theillustrated embodiment, the hash process is the SHA1 operation. In step630, the security module calculates the SHA1 value based on theauthorized server public key that is received from the local host. Instep 640, the calculated value is compared to the received value. Amatch implies that the server public key is in fact authorized.

FIG. 7 illustrates the process of the secure handshake that takes placebetween a client and a key server. This handshake serves to initiate thetransport layer security (TLS) protocol. The process begins at step 705.In step 710, the client generates a random number at the securitymodule. In step 715, a copy of the random number is saved. In step 720,a message is formed based on this client random number. In step 725, theclient sends this client random number to the key server. Thistransmission is sometimes referred to as the client hello.

In step 730, the server generates its own random number. In step 735,the server signs a session public key. In step 740, the server sends itsserver random number and the signed session public key (sometimes knownas the server hello) and a certificate to the local host of the client.In step 745, the local host parses the server hello, and extracts theserver random number and the signed session public key. In step 750, thelocal host sends the signed session public key to the security module.In step 755, the security module verifies the signed session public key.In step 760, the handshake concludes with a verification process that isbased on all the preceding communications between the client and the keyserver. Steps 755 and 760 are described in more detail below. Theprocess concludes at step 765.

Step 755 above, the step of verifying the signed session public key, isillustrated in greater detail in FIG. 8. The process begins at step 810.In step 820, the local host parses the certificate. In step 830, thelocal host finds the public key that corresponds to the server. In step840, a determination is made as to whether the key corresponds to theprospective authorized server. If not, verification can be requestedfrom the server in step 870, and the authorization obtained in step 880.In step 850, the security module loads the corresponding public key. Instep 860, this public key is used to verify the signed session publickey. The process concludes at step 890.

Step 760 above, the step of verifying the handshake process, isillustrated in greater detail in FIG. 9. The process starts with step910. In step 920, the client sends the client certificate to the keyserver. In step 930, the exchange of keys takes place. In step 940, theclient incorporates the session public key into a finished hash value.In step 950, the client sends its finished message, including the abovehash value, to the server. In step 960, the server sends its finishedmessage to the client. The process concludes at step 970.

Note that the handshake process as illustrated in FIGS. 5 through 9presumes the use of the Diffie Hellman public key process. Inalternative embodiments of the invention, other public key processes canbe used, such as the Rivest Shamir Adleman (RSA) process.

The process by which persistent data can now be transferred from thelocal host to the security module is illustrated in FIG. 10. The processbegins at step 1010. In step 1020, the security module receives a secureconfiguration message from the local host. As described above, theconfiguration message is typically in encrypted form. In step 1030, adetermination is made as to whether an authorized signature is present.If not, then the secure configuration message is not used, as shown instep 1050. If an authorized signature is present, then the configurationmessage is loaded at the security module. Note that the determination ofstep 1030 comprises the determination as to whether the signature isverified as that of one of the authorized public keys. The processconcludes at step 1060.

FIG. 11 illustrates a process by which a key can be transferred aspersistent data from a local host to the security module. The processbegins at step 1105. In step 1110, the client establishes a secureconnection with the authorized server. In step 1115, the key serversends a time value with a key in a numbered message to the client. Instep 1120, the client loads the key at the key cache in the securitymodule. In step 1125, a countdown timer is set at the key cacheaccording to the received time value. Note that in an embodiment of theinvention, the timer is implemented in hardware at the key cache. Instep 1130, the timer is decremented. In step 1135 a determination ismade as to whether the timer has reached zero, i.e., expired. If so,then in step 1140, the key is rendered unusable. If the timer has notyet expired, a determination is made as to whether a new time value hasarrived. If so, again, the existing key is rendered unusable in step1140. If no new time value has arrived, then the key is considered to beusable in step 1150. The process then returns to step 1130 where thetimer is further decremented. Hence, a key is rendered unusable if thetimer has expired or if a new time value has arrived. Hence, a new timevalue has the effect of flushing out any preexisting key that isassociated with the previous time value. Also, as described above, thetime value is sent in a numbered message in an embodiment of theinvention. This prevents an adversary from copying a previous messageand replaying it to a client.

The process of configuring or reconfiguring the logic in the securitymodule using a configuration message is illustrated in FIG. 12. Theprocess begins at step 1210. In step 1220, the local host receives asecure configuration message. In step 1230, the configuration command isincorporated into the boot process. In step 1240, the configurationcommand is sent to the security module at the time of booting. In step1250, the security module is reconfigured according to the command,provided that an accompanying signature is validated. The processconcludes at step 1260.

IV. CONCLUSION

While various embodiments of the present invention have been describedabove it should be understood that they have been presented by way ofexample, and not limitation. It would be apparent to persons skilled inthe relevant art that various changes in detail can be made thereinwithout departing from the spirit and scope of the invention. Thus, thepresent invention should not be limited by any of the above describedexemplary embodiments.

What is claimed is:
 1. A client device configured to create a hierarchyof key servers, the client device comprising: a local host configured totransfer a first public key associated with a first key server, whereinthe first public key is configured to expire after a predeterminedperiod of time; and a security module configured to: determine that thefirst key server is authorized by comparing information stored in thesecurity module with a hash value of the first public key, determinewhether the first key server is permitted to authorize additional keyservers, and sign a second public key of a second key server with thefirst public key to authorize the second key server in response todetermining that the first key server is permitted to authorizeadditional key servers.
 2. The client device of claim 1, wherein thesecurity module is further configured to authorize an additional keyserver using the first public key or the second public key.
 3. Theclient device of claim 1, wherein the first public key is configured toexpire after a countdown timer reaches zero.
 4. The client device ofclaim 1, wherein the security module is further configured to: receive aconfiguration message from the local host; determine whether theconfiguration message is accompanied by a signature created by anauthorized public key; and load content of the configuration message inresponse to determining that the configuration message is accompanied bythe signature.
 5. The client device of claim 4, wherein theconfiguration message is configured to alter a functionality availableto the security module.
 6. The client device of claim 4, wherein theconfiguration message is configured to place a constraint on key lengthor remove a constraint on key length.
 7. The client device of claim 4,wherein the configuration message is configured to determine how a givenkey is to be used in accordance with a system security policy.
 8. Theclient device of claim 4, wherein the configuration message isconfigured to determine a time interval over which a given key isusable, in accordance with a system security policy.
 9. A client deviceconfigured to establish an authenticated connection with a key server,the client device comprising: a local host configured to transfer afirst public key associated with the key server, wherein the firstpublic key is configured to expire after a predetermined period of time;and a security module configured to: send a client random number to thekey server, receive a server random number, a signed session key, and acertificate from the key server, determine whether the signed sessionkey has been signed with a verified public key, and compare a hash ofthe first public key with information stored in the security module. 10.The client device of claim 9, wherein the security module is furtherconfigured to: generate the client random number.
 11. The client deviceof claim 9, wherein the security module is further configured to: storethe client random number.
 12. The client device of claim 9, wherein thesecurity module is further configured to: verify the signed session keyin response to determining that the signed session key has been signedwith the verified public key.
 13. The client device of claim 9, whereinthe security module is further configured to: verify a handshake processwith the key server in response to comparing the hash of the firstpublic key with the information stored in the security module.
 14. Theclient device of claim 9, wherein the security module is furtherconfigured to: send a client certificate to the key server; engage in akey exchange with the key server; incorporate a client session key intoa finished hash; send a client finished message to the key server; andreceive a server finished message from the key server.
 15. The clientdevice of claim 9, wherein the security module is further configured to:receive a key and a time value from the key server; load the key at akey cache; set a countdown timer to the time value; and decrement thecountdown timer.
 16. The client device of claim 15, wherein the securitymodule is further configured to: render the key unusable if thecountdown timer reaches zero or a next key is received from the keyserver with a next time value.
 17. A security module configured tocreate a hierarchy of key servers, the security module comprising: amemory; and a controller configured to: determine that the first keyserver is authorized by comparing information stored in the securitymodule with a hash value of a first public key associated with a firstkey server, wherein the first public key is configured to expire after apredetermined period of time, determine whether the first key server ispermitted to authorize additional key servers, and sign a second publickey of a second key server with the first public key to authorize thesecond key server in response to determining that the first key serveris permitted to authorize additional key servers.
 18. The securitymodule of claim 17, wherein the security module is further configured toauthorize an additional key server using the first public key or thesecond public key.
 19. The security module of claim 17, wherein thesecurity module is further configured to: receive a configurationmessage from a local host; determine whether the configuration messageis accompanied by a signature created by an authorized public key; andload content of the configuration message in response to determiningthat the configuration message is accompanied by the signature.
 20. Thesecurity module of claim 17, wherein the configuration message isconfigured to alter a functionality available to the security module.